x/ccv/provider/module_test.go (1)

Line range hint 12-12: Please reorder the imports according to the Golang style guide.

-	"github.com/golang/mock/gomock"
+	"github.com/cosmos/ibc-go/v7/modules/core/24-host"
+	"github.com/golang/mock/gomock"

Tools

golangci-lint

18-18: File is not gci-ed with --skip-generated -s standard -s default -s blank -s dot -s prefix(cosmossdk.io) -s prefix(github.com/cosmos/cosmos-sdk) -s prefix(github.com/cometbft/cometbft) -s prefix(github.com/cosmos/interchain-security) --custom-order (gci)

x/ccv/provider/module.go (1)

Line range hint 30-30: The AppModule struct needs to implement the OnAcknowledgementPacket method to satisfy the IBCModule interface.

+ func (am AppModule) OnAcknowledgementPacket(ctx sdk.Context, packet channeltypes.Packet, acknowledgement []byte, relayer sdk.AccAddress) (*sdk.Result, error) {
+     // Implementation goes here
+     return nil, nil
+ }

x/ccv/provider/keeper/partial_set_security.go (1)

Line range hint 92-103: Refactor to use more efficient sorting and power summing methods.

The current method for computing the minimum power to opt in is inefficient as it sorts the entire list of validator powers and then computes a running total. Consider using a min-heap for a more efficient approach.

import "container/heap"

// Use a min-heap to keep track of the smallest powers, which allows us to quickly access the top N powers.
type IntHeap []int64

func (h IntHeap) Len() int           { return len(h) }
func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] }
func (h IntHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }

func (h *IntHeap) Push(x interface{}) {
    *h = append(*h, x.(int64))
}

func (h *IntHeap) Pop() interface{} {
    old := *h
    n := len(old)
    x := old[n-1]
    *h = old[0 : n-1]
    return x
}

// In your function:
powersHeap := &IntHeap{}
heap.Init(powersHeap)
for _, val := range bondedValidators {
    heap.Push(powersHeap, val.Power)
    if powersHeap.Len() > int(topN) {
        heap.Pop(powersHeap)
    }
}
minPowerToOptIn := (*powersHeap)[0] // The smallest power in the top N
return minPowerToOptIn, nil

x/ccv/provider/keeper/validator_set_update_test.go (2)

Line range hint 233-233: Consider making "chainID" a constant to avoid repetition.

- chainID := "chainID"
+ const chainID = "chainID"

---

Line range hint 321-332: Refactor repeated validator creation code into a shared helper function.

- valA := testkeeper.CreateStakingValidator(ctx, mocks, 1, 1)
- valB := testkeeper.CreateStakingValidator(ctx, mocks, 2, 2)
+ valA, valB := createTestValidators(ctx, mocks, []int{1, 2}, []int{1, 2})

// Helper function
func createTestValidators(ctx sdk.Context, mocks MockedKeepers, indices []int, powers []int64) ([]stakingtypes.Validator, []crypto.PublicKey) {
    var validators []stakingtypes.Validator
    var publicKeys []crypto.PublicKey
    for i, index := range indices {
        validator, publicKey := testkeeper.CreateStakingValidator(ctx, mocks, index, powers[i])
        validators = append(validators, validator)
        publicKeys = append(publicKeys, publicKey)
    }
    return validators, publicKeys
}

Also applies to: 363-375, 410-410, 429-429, 444-444

x/ccv/provider/keeper/proposal.go (4)

Line range hint 281-281: Undefined function DiffValidators detected.

Please ensure that the function DiffValidators is defined or imported correctly in this file. If it's defined in another package, you might need to import it.

---

Line range hint 30-30: Ensure the Keeper type is defined or imported correctly.

It seems there's a recurring issue with the Keeper type being undefined. Please check the import statements and ensure that the Keeper type is correctly defined and accessible in this context.

---

Line range hint 53-53: Ensure the Keeper type is defined or imported correctly.

This issue with the Keeper type being undefined appears multiple times. It's crucial to resolve this to prevent runtime errors.

---

Line range hint 129-129: Ensure the Keeper type is defined or imported correctly.

The recurring issue with the Keeper type being undefined needs thorough investigation. Please check all relevant import statements and definitions.

x/ccv/provider/keeper/proposal_test.go (1)

Line range hint 1128-1128: The variable found is reassigned but never used afterwards, which could be an oversight or unnecessary code.

-	found = providerKeeper.PendingConsumerRemovalPropExists(
-		ctx, invalidProp.ChainId, invalidProp.StopTime)
-	require.False(t, found)
+	_ = providerKeeper.PendingConsumerRemovalPropExists(
+		ctx, invalidProp.ChainId, invalidProp.StopTime)

Tools

golangci-lint

10-10: File is not gci-ed with --skip-generated -s standard -s default -s blank -s dot -s prefix(cosmossdk.io) -s prefix(github.com/cosmos/cosmos-sdk) -s prefix(github.com/cometbft/cometbft) -s prefix(github.com/cosmos/interchain-security) --custom-order (gci)

tests/e2e/config.go (1)

90-90: Add documentation for InactiveValsCfg.

It would be beneficial to add a comment explaining the purpose and usage of the InactiveValsCfg configuration type, especially since it relates to the new feature of allowing inactive validators.

x/ccv/provider/keeper/partial_set_security_test.go (2)

119-142: Check for potential redundant mock expectations

The GetValidatorByConsAddr method of MockStakingKeeper is expected to be called any number of times with specific addresses. This setup could potentially be simplified or explained better to ensure that it's clear why it's needed for each validator and that it does not mask other potential issues in the test logic.

---

Line range hint 381-391: Optimization suggestion for list manipulations

When manipulating lists such as allowlists and denylists, consider checking if operations can be optimized or if there are redundant operations that could be streamlined. This can improve the performance and readability of the test code.

x/ccv/provider/keeper/relay.go (1)

Line range hint 149-171: Refactor EndBlockVSU for clarity and error handling.

The EndBlockVSU method is complex and handles multiple responsibilities. Consider refactoring it to improve readability and maintainability. Additionally, ensure that all operations have appropriate error handling to prevent potential issues during the block end logic.

func (k Keeper) EndBlockVSU(ctx sdk.Context) []abci.ValidatorUpdate {
+   var err error
    providerUpdates := k.ProviderValidatorUpdates(ctx)
    if providerUpdates == nil {
+       return nil
    }

    k.completeMaturedUnbondingOps(ctx)

    if ctx.BlockHeight()%k.GetBlocksPerEpoch(ctx) == 0 {
        k.QueueVSCPackets(ctx)
-       k.SendVSCPackets(ctx)
+       if err = k.SendVSCPackets(ctx); err != nil {
+           k.Logger(ctx).Error("Failed to send VSC packets", "error", err)
+       }
    }

    return providerUpdates
}